
/**
 * Require the given path.
 *
 * @param {String} path
 * @return {Object} exports
 * @api public
 */

function require(path, parent, orig) {
    var resolved = require.resolve(path);
  
    // lookup failed
    if (null == resolved) {
      orig = orig || path;
      parent = parent || 'root';
      var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
      err.path = orig;
      err.parent = parent;
      err.require = true;
      throw err;
    }
  
    var module = require.modules[resolved];
  
    // perform real require()
    // by invoking the module's
    // registered function
    if (!module._resolving && !module.exports) {
      var mod = {};
      mod.exports = {};
      mod.client = mod.component = true;
      module._resolving = true;
      module.call(this, mod.exports, require.relative(resolved), mod);
      delete module._resolving;
      module.exports = mod.exports;
    }
  
    return module.exports;
  }
  
  /**
   * Registered modules.
   */
  
  require.modules = {};
  
  /**
   * Registered aliases.
   */
  
  require.aliases = {};
  
  /**
   * Resolve `path`.
   *
   * Lookup:
   *
   *   - PATH/index.js
   *   - PATH.js
   *   - PATH
   *
   * @param {String} path
   * @return {String} path or null
   * @api private
   */
  
  require.resolve = function(path) {
    if (path.charAt(0) === '/') path = path.slice(1);
  
    var paths = [
      path,
      path + '.js',
      path + '.json',
      path + '/index.js',
      path + '/index.json'
    ];
  
    for (var i = 0; i < paths.length; i++) {
      var path = paths[i];
      if (require.modules.hasOwnProperty(path)) return path;
      if (require.aliases.hasOwnProperty(path)) return require.aliases[path];
    }
  };
  
  /**
   * Normalize `path` relative to the current path.
   *
   * @param {String} curr
   * @param {String} path
   * @return {String}
   * @api private
   */
  
  require.normalize = function(curr, path) {
    var segs = [];
  
    if ('.' != path.charAt(0)) return path;
  
    curr = curr.split('/');
    path = path.split('/');
  
    for (var i = 0; i < path.length; ++i) {
      if ('..' == path[i]) {
        curr.pop();
      } else if ('.' != path[i] && '' != path[i]) {
        segs.push(path[i]);
      }
    }
  
    return curr.concat(segs).join('/');
  };
  
  /**
   * Register module at `path` with callback `definition`.
   *
   * @param {String} path
   * @param {Function} definition
   * @api private
   */
  
  require.register = function(path, definition) {
    require.modules[path] = definition;
  };
  
  /**
   * Alias a module definition.
   *
   * @param {String} from
   * @param {String} to
   * @api private
   */
  
  require.alias = function(from, to) {
    if (!require.modules.hasOwnProperty(from)) {
      throw new Error('Failed to alias "' + from + '", it does not exist');
    }
    require.aliases[to] = from;
  };
  
  /**
   * Return a require function relative to the `parent` path.
   *
   * @param {String} parent
   * @return {Function}
   * @api private
   */
  
  require.relative = function(parent) {
    var p = require.normalize(parent, '..');
  
    /**
     * lastIndexOf helper.
     */
  
    function lastIndexOf(arr, obj) {
      var i = arr.length;
      while (i--) {
        if (arr[i] === obj) return i;
      }
      return -1;
    }
  
    /**
     * The relative require() itself.
     */
  
    function localRequire(path) {
      var resolved = localRequire.resolve(path);
      return require(resolved, parent, path);
    }
  
    /**
     * Resolve relative to the parent.
     */
  
    localRequire.resolve = function(path) {
      var c = path.charAt(0);
      if ('/' == c) return path.slice(1);
      if ('.' == c) return require.normalize(p, path);
  
      // resolve deps by returning
      // the dep in the nearest "deps"
      // directory
      var segs = parent.split('/');
      var i = lastIndexOf(segs, 'deps') + 1;
      if (!i) i = 0;
      path = segs.slice(0, i + 1).join('/') + '/deps/' + path;
      return path;
    };
  
    /**
     * Check if module is defined at `path`.
     */
  
    localRequire.exists = function(path) {
      return require.modules.hasOwnProperty(localRequire.resolve(path));
    };
  
    return localRequire;
  };
  require.register("component-transform-property/index.js", function(exports, require, module){
  
  var styles = [
    'webkitTransform',
    'MozTransform',
    'msTransform',
    'OTransform',
    'transform'
  ];
  
  var el = document.createElement('p');
  var style;
  
  for (var i = 0; i < styles.length; i++) {
    style = styles[i];
    if (null != el.style[style]) {
      module.exports = style;
      break;
    }
  }
  
  });
  require.register("component-has-translate3d/index.js", function(exports, require, module){
  
  var prop = require('transform-property');
  // IE8<= doesn't have `getComputedStyle`
  if (!prop || !window.getComputedStyle) return module.exports = false;
  
  var map = {
    webkitTransform: '-webkit-transform',
    OTransform: '-o-transform',
    msTransform: '-ms-transform',
    MozTransform: '-moz-transform',
    transform: 'transform'
  };
  
  // from: https://gist.github.com/lorenzopolidori/3794226
  var el = document.createElement('div');
  el.style[prop] = 'translate3d(1px,1px,1px)';
  document.body.insertBefore(el, null);
  var val = getComputedStyle(el).getPropertyValue(map[prop]);
  document.body.removeChild(el);
  module.exports = null != val && val.length && 'none' != val;
  
  });
  require.register("yields-has-transitions/index.js", function(exports, require, module){
  /**
   * Check if `el` or browser supports transitions.
   *
   * @param {Element} el
   * @return {Boolean}
   * @api public
   */
  
  exports = module.exports = function(el){
    switch (arguments.length) {
      case 0: return bool;
      case 1: return bool
        ? transitions(el)
        : bool;
    }
  };
  
  /**
   * Check if the given `el` has transitions.
   *
   * @param {Element} el
   * @return {Boolean}
   * @api private
   */
  
  function transitions(el, styl){
    if (el.transition) return true;
    styl = window.getComputedStyle(el);
    return !! parseFloat(styl.transitionDuration, 10);
  }
  
  /**
   * Style.
   */
  
  var styl = document.body.style;
  
  /**
   * Export support.
   */
  
  var bool = 'transition' in styl
    || 'webkitTransition' in styl
    || 'MozTransition' in styl
    || 'msTransition' in styl;
  
  });
  require.register("component-event/index.js", function(exports, require, module){
  
  /**
   * Bind `el` event `type` to `fn`.
   *
   * @param {Element} el
   * @param {String} type
   * @param {Function} fn
   * @param {Boolean} capture
   * @return {Function}
   * @api public
   */
  
  exports.bind = function(el, type, fn, capture){
    if (el.addEventListener) {
      el.addEventListener(type, fn, capture || false);
    } else {
      el.attachEvent('on' + type, fn);
    }
    return fn;
  };
  
  /**
   * Unbind `el` event `type`'s callback `fn`.
   *
   * @param {Element} el
   * @param {String} type
   * @param {Function} fn
   * @param {Boolean} capture
   * @return {Function}
   * @api public
   */
  
  exports.unbind = function(el, type, fn, capture){
    if (el.removeEventListener) {
      el.removeEventListener(type, fn, capture || false);
    } else {
      el.detachEvent('on' + type, fn);
    }
    return fn;
  };
  
  });
  require.register("ecarter-css-emitter/index.js", function(exports, require, module){
  /**
   * Module Dependencies
   */
  
  var events = require('event');
  
  // CSS events
  
  var watch = [
    'transitionend'
  , 'webkitTransitionEnd'
  , 'oTransitionEnd'
  , 'MSTransitionEnd'
  , 'animationend'
  , 'webkitAnimationEnd'
  , 'oAnimationEnd'
  , 'MSAnimationEnd'
  ];
  
  /**
   * Expose `CSSnext`
   */
  
  module.exports = CssEmitter;
  
  /**
   * Initialize a new `CssEmitter`
   *
   */
  
  function CssEmitter(element){
    if (!(this instanceof CssEmitter)) return new CssEmitter(element);
    this.el = element;
  }
  
  /**
   * Bind CSS events.
   *
   * @api public
   */
  
  CssEmitter.prototype.bind = function(fn){
    for (var i=0; i < watch.length; i++) {
      events.bind(this.el, watch[i], fn);
    }
  };
  
  /**
   * Unbind CSS events
   * 
   * @api public
   */
  
  CssEmitter.prototype.unbind = function(fn){
    for (var i=0; i < watch.length; i++) {
      events.unbind(this.el, watch[i], fn);
    }
  };
  
  
  
  });
  require.register("component-once/index.js", function(exports, require, module){
  
  /**
   * Identifier.
   */
  
  var n = 0;
  
  /**
   * Global.
   */
  
  var global = (function(){ return this })();
  
  /**
   * Make `fn` callable only once.
   *
   * @param {Function} fn
   * @return {Function}
   * @api public
   */
  
  module.exports = function(fn) {
    var id = n++;
    var called;
  
    function once(){
      // no receiver
      if (this == global) {
        if (called) return;
        called = true;
        return fn.apply(this, arguments);
      }
  
      // receiver
      var key = '__called_' + id + '__';
      if (this[key]) return;
      this[key] = true;
      return fn.apply(this, arguments);
    }
  
    return once;
  };
  
  });
  require.register("yields-after-transition/index.js", function(exports, require, module){
  
  /**
   * dependencies
   */
  
  var has = require('has-transitions')
    , emitter = require('css-emitter')
    , once = require('once');
  
  /**
   * Transition support.
   */
  
  var supported = has();
  
  /**
   * Export `after`
   */
  
  module.exports = after;
  
  /**
   * Invoke the given `fn` after transitions
   *
   * It will be invoked only if the browser
   * supports transitions __and__
   * the element has transitions
   * set in `.style` or css.
   *
   * @param {Element} el
   * @param {Function} fn
   * @return {Function} fn
   * @api public
   */
  
  function after(el, fn){
    if (!supported || !has(el)) return fn();
    emitter(el).bind(fn);
    return fn;
  };
  
  /**
   * Same as `after()` only the function is invoked once.
   *
   * @param {Element} el
   * @param {Function} fn
   * @return {Function}
   * @api public
   */
  
  after.once = function(el, fn){
    var callback = once(fn);
    after(el, fn = function(){
      emitter(el).unbind(fn);
      callback();
    });
  };
  
  });
  require.register("component-type/index.js", function(exports, require, module){
  
  /**
   * toString ref.
   */
  
  var toString = Object.prototype.toString;
  
  /**
   * Return the type of `val`.
   *
   * @param {Mixed} val
   * @return {String}
   * @api public
   */
  
  module.exports = function(val){
    switch (toString.call(val)) {
      case '[object Function]': return 'function';
      case '[object Date]': return 'date';
      case '[object RegExp]': return 'regexp';
      case '[object Arguments]': return 'arguments';
      case '[object Array]': return 'array';
      case '[object String]': return 'string';
    }
  
    if (val === null) return 'null';
    if (val === undefined) return 'undefined';
    if (val && val.nodeType === 1) return 'element';
    if (val === Object(val)) return 'object';
  
    return typeof val;
  };
  
  });
  require.register("ianstormtaylor-to-no-case/index.js", function(exports, require, module){
  
  /**
   * Expose `toNoCase`.
   */
  
  module.exports = toNoCase;
  
  
  /**
   * Test whether a string is camel-case.
   */
  
  var hasSpace = /\s/;
  var hasCamel = /[a-z][A-Z]/;
  var hasSeparator = /[\W_]/;
  
  
  /**
   * Remove any starting case from a `string`, like camel or snake, but keep
   * spaces and punctuation that may be important otherwise.
   *
   * @param {String} string
   * @return {String}
   */
  
  function toNoCase (string) {
    if (hasSpace.test(string)) return string.toLowerCase();
  
    if (hasSeparator.test(string)) string = unseparate(string);
    if (hasCamel.test(string)) string = uncamelize(string);
    return string.toLowerCase();
  }
  
  
  /**
   * Separator splitter.
   */
  
  var separatorSplitter = /[\W_]+(.|$)/g;
  
  
  /**
   * Un-separate a `string`.
   *
   * @param {String} string
   * @return {String}
   */
  
  function unseparate (string) {
    return string.replace(separatorSplitter, function (m, next) {
      return next ? ' ' + next : '';
    });
  }
  
  
  /**
   * Camelcase splitter.
   */
  
  var camelSplitter = /(.)([A-Z]+)/g;
  
  
  /**
   * Un-camelcase a `string`.
   *
   * @param {String} string
   * @return {String}
   */
  
  function uncamelize (string) {
    return string.replace(camelSplitter, function (m, previous, uppers) {
      return previous + ' ' + uppers.toLowerCase().split('').join(' ');
    });
  }
  });
  require.register("ianstormtaylor-to-space-case/index.js", function(exports, require, module){
  
  var clean = require('to-no-case');
  
  
  /**
   * Expose `toSpaceCase`.
   */
  
  module.exports = toSpaceCase;
  
  
  /**
   * Convert a `string` to space case.
   *
   * @param {String} string
   * @return {String}
   */
  
  
  function toSpaceCase (string) {
    return clean(string).replace(/[\W_]+(.|$)/g, function (matches, match) {
      return match ? ' ' + match : '';
    });
  }
  });
  require.register("ianstormtaylor-to-camel-case/index.js", function(exports, require, module){
  
  var toSpace = require('to-space-case');
  
  
  /**
   * Expose `toCamelCase`.
   */
  
  module.exports = toCamelCase;
  
  
  /**
   * Convert a `string` to camel case.
   *
   * @param {String} string
   * @return {String}
   */
  
  
  function toCamelCase (string) {
    return toSpace(string).replace(/\s(\w)/g, function (matches, letter) {
      return letter.toUpperCase();
    });
  }
  });
  require.register("jkroso-computed-style/index.js", function(exports, require, module){
  
  /**
   * Get the computed style of a DOM element
   * 
   *   style(document.body) // => {width:'500px', ...}
   * 
   * @param {Element} element
   * @return {Object}
   */
  
  // Accessing via window for jsDOM support
  module.exports = window.getComputedStyle
  
  // Fallback to elem.currentStyle for IE < 9
  if (!module.exports) {
      module.exports = function (elem) {
          return elem.currentStyle
      }
  }
  
  });
  require.register("ianstormtaylor-css/index.js", function(exports, require, module){
  
  var camel = require('to-camel-case')
    , computed = require('computed-style')
    , type = require('type');
  
  
  /**
   * Expose `css`.
   */
  
  module.exports = css;
  
  /**
   * Don't append `px`.
   */
  
  var ignore = {
    columnCount: true,
    fillOpacity: true,
    fontWeight: true,
    lineHeight: true,
    opacity: true,
    orphans: true,
    widows: true,
    zIndex: true,
    zoom: true
  };
  
  /**
   * Get or set CSS properties of an `el`.
   *
   * @param {Element} el
   * @param {String|Object} prop
   * @param {String} value (optional)
   */
  
  function css (el, prop, value) {
    if (type(prop) == 'object') {
      for (var key in prop) set(el, key, prop[key]);
      return;
    }
  
    return arguments.length == 3
      ? set(el, prop, value)
      : get(el, prop);
  }
  
  
  /**
   * Get the current CSS `prop` value of an `el`.
   *
   * @param {Element} el
   * @param {String} prop
   */
  
  function get (el, prop) {
    return computed(el)[prop];
  }
  
  
  /**
   * Set a CSS `prop` to `value` on an `element`.
   *
   * @param {Element} element
   * @param {String} prop
   * @param {String} value
   */
  
  function set (el, prop, value) {
    prop = camel(prop);
    if ('number' == typeof value && !ignore[prop]) value += 'px';
    el.style[prop] = value;
  }
  
  });
  require.register("component-indexof/index.js", function(exports, require, module){
  module.exports = function(arr, obj){
    if (arr.indexOf) return arr.indexOf(obj);
    for (var i = 0; i < arr.length; ++i) {
      if (arr[i] === obj) return i;
    }
    return -1;
  };
  });
  require.register("component-emitter/index.js", function(exports, require, module){
  
  /**
   * Module dependencies.
   */
  
  var index = require('indexof');
  
  /**
   * Expose `Emitter`.
   */
  
  module.exports = Emitter;
  
  /**
   * Initialize a new `Emitter`.
   *
   * @api public
   */
  
  function Emitter(obj) {
    if (obj) return mixin(obj);
  };
  
  /**
   * Mixin the emitter properties.
   *
   * @param {Object} obj
   * @return {Object}
   * @api private
   */
  
  function mixin(obj) {
    for (var key in Emitter.prototype) {
      obj[key] = Emitter.prototype[key];
    }
    return obj;
  }
  
  /**
   * Listen on the given `event` with `fn`.
   *
   * @param {String} event
   * @param {Function} fn
   * @return {Emitter}
   * @api public
   */
  
  Emitter.prototype.on = function(event, fn){
    this._callbacks = this._callbacks || {};
    (this._callbacks[event] = this._callbacks[event] || [])
      .push(fn);
    return this;
  };
  
  /**
   * Adds an `event` listener that will be invoked a single
   * time then automatically removed.
   *
   * @param {String} event
   * @param {Function} fn
   * @return {Emitter}
   * @api public
   */
  
  Emitter.prototype.once = function(event, fn){
    var self = this;
    this._callbacks = this._callbacks || {};
  
    function on() {
      self.off(event, on);
      fn.apply(this, arguments);
    }
  
    fn._off = on;
    this.on(event, on);
    return this;
  };
  
  /**
   * Remove the given callback for `event` or all
   * registered callbacks.
   *
   * @param {String} event
   * @param {Function} fn
   * @return {Emitter}
   * @api public
   */
  
  Emitter.prototype.off =
  Emitter.prototype.removeListener =
  Emitter.prototype.removeAllListeners = function(event, fn){
    this._callbacks = this._callbacks || {};
  
    // all
    if (0 == arguments.length) {
      this._callbacks = {};
      return this;
    }
  
    // specific event
    var callbacks = this._callbacks[event];
    if (!callbacks) return this;
  
    // remove all handlers
    if (1 == arguments.length) {
      delete this._callbacks[event];
      return this;
    }
  
    // remove specific handler
    var i = index(callbacks, fn._off || fn);
    if (~i) callbacks.splice(i, 1);
    return this;
  };
  
  /**
   * Emit `event` with the given args.
   *
   * @param {String} event
   * @param {Mixed} ...
   * @return {Emitter}
   */
  
  Emitter.prototype.emit = function(event){
    this._callbacks = this._callbacks || {};
    var args = [].slice.call(arguments, 1)
      , callbacks = this._callbacks[event];
  
    if (callbacks) {
      callbacks = callbacks.slice(0);
      for (var i = 0, len = callbacks.length; i < len; ++i) {
        callbacks[i].apply(this, args);
      }
    }
  
    return this;
  };
  
  /**
   * Return array of callbacks for `event`.
   *
   * @param {String} event
   * @return {Array}
   * @api public
   */
  
  Emitter.prototype.listeners = function(event){
    this._callbacks = this._callbacks || {};
    return this._callbacks[event] || [];
  };
  
  /**
   * Check if this emitter has `event` handlers.
   *
   * @param {String} event
   * @return {Boolean}
   * @api public
   */
  
  Emitter.prototype.hasListeners = function(event){
    return !! this.listeners(event).length;
  };
  
  });
  require.register("yields-css-ease/index.js", function(exports, require, module){
  
  /**
   * CSS Easing functions
   */
  
  module.exports = {
      'in':                'ease-in'
    , 'out':               'ease-out'
    , 'in-out':            'ease-in-out'
    , 'snap':              'cubic-bezier(0,1,.5,1)'
    , 'linear':            'cubic-bezier(0.250, 0.250, 0.750, 0.750)'
    , 'ease-in-quad':      'cubic-bezier(0.550, 0.085, 0.680, 0.530)'
    , 'ease-in-cubic':     'cubic-bezier(0.550, 0.055, 0.675, 0.190)'
    , 'ease-in-quart':     'cubic-bezier(0.895, 0.030, 0.685, 0.220)'
    , 'ease-in-quint':     'cubic-bezier(0.755, 0.050, 0.855, 0.060)'
    , 'ease-in-sine':      'cubic-bezier(0.470, 0.000, 0.745, 0.715)'
    , 'ease-in-expo':      'cubic-bezier(0.950, 0.050, 0.795, 0.035)'
    , 'ease-in-circ':      'cubic-bezier(0.600, 0.040, 0.980, 0.335)'
    , 'ease-in-back':      'cubic-bezier(0.600, -0.280, 0.735, 0.045)'
    , 'ease-out-quad':     'cubic-bezier(0.250, 0.460, 0.450, 0.940)'
    , 'ease-out-cubic':    'cubic-bezier(0.215, 0.610, 0.355, 1.000)'
    , 'ease-out-quart':    'cubic-bezier(0.165, 0.840, 0.440, 1.000)'
    , 'ease-out-quint':    'cubic-bezier(0.230, 1.000, 0.320, 1.000)'
    , 'ease-out-sine':     'cubic-bezier(0.390, 0.575, 0.565, 1.000)'
    , 'ease-out-expo':     'cubic-bezier(0.190, 1.000, 0.220, 1.000)'
    , 'ease-out-circ':     'cubic-bezier(0.075, 0.820, 0.165, 1.000)'
    , 'ease-out-back':     'cubic-bezier(0.175, 0.885, 0.320, 1.275)'
    , 'ease-out-quad':     'cubic-bezier(0.455, 0.030, 0.515, 0.955)'
    , 'ease-out-cubic':    'cubic-bezier(0.645, 0.045, 0.355, 1.000)'
    , 'ease-in-out-quart': 'cubic-bezier(0.770, 0.000, 0.175, 1.000)'
    , 'ease-in-out-quint': 'cubic-bezier(0.860, 0.000, 0.070, 1.000)'
    , 'ease-in-out-sine':  'cubic-bezier(0.445, 0.050, 0.550, 0.950)'
    , 'ease-in-out-expo':  'cubic-bezier(1.000, 0.000, 0.000, 1.000)'
    , 'ease-in-out-circ':  'cubic-bezier(0.785, 0.135, 0.150, 0.860)'
    , 'ease-in-out-back':  'cubic-bezier(0.680, -0.550, 0.265, 1.550)'
  };
  
  });
  require.register("component-query/index.js", function(exports, require, module){
  
  function one(selector, el) {
    return el.querySelector(selector);
  }
  
  exports = module.exports = function(selector, el){
    el = el || document;
    return one(selector, el);
  };
  
  exports.all = function(selector, el){
    el = el || document;
    return el.querySelectorAll(selector);
  };
  
  exports.engine = function(obj){
    if (!obj.one) throw new Error('.one callback required');
    if (!obj.all) throw new Error('.all callback required');
    one = obj.one;
    exports.all = obj.all;
  };
  
  });
  require.register("visionmedia-move.js/index.js", function(exports, require, module){
  
  /**
   * Module Dependencies.
   */
  
  var after = require('after-transition');
  var has3d = require('has-translate3d');
  var Emitter = require('emitter');
  var ease = require('css-ease');
  var query = require('query');
  var css = require('css');
  
  /**
   * CSS Translate
   */
  
  var translate = has3d
    ? ['translate3d(', ', 0)']
    : ['translate(', ')'];
  
  /**
   * Export `Move`
   */
  
  module.exports = Move;
  
  /**
   * Get computed style.
   */
  
  var style = window.getComputedStyle
    || window.currentStyle;
  
  /**
   * Library version.
   */
  
  Move.version = '0.3.2';
  
  /**
   * Export `ease`
   */
  
  Move.ease = ease;
  
  /**
   * Defaults.
   *
   *   `duration` - default duration of 500ms
   *
   */
  
  Move.defaults = {
    duration: 500
  };
  
  /**
   * Default element selection utilized by `move(selector)`.
   *
   * Override to implement your own selection, for example
   * with jQuery one might write:
   *
   *     move.select = function(selector) {
   *       return jQuery(selector).get(0);
   *     };
   *
   * @param {Object|String} selector
   * @return {Element}
   * @api public
   */
  
  Move.select = function(selector){
    if ('string' != typeof selector) return selector;
    return query(selector);
  };
  
  /**
   * Initialize a new `Move` with the given `el`.
   *
   * @param {Element} el
   * @api public
   */
  
  function Move(el) {
    if (!(this instanceof Move)) return new Move(el);
    if ('string' == typeof el) el = query(el);
    if (!el) throw new TypeError('Move must be initialized with element or selector');
    this.el = el;
    this._props = {};
    this._rotate = 0;
    this._transitionProps = [];
    this._transforms = [];
    this.duration(Move.defaults.duration)
  };
  
  
  /**
   * Inherit from `EventEmitter.prototype`.
   */
  
  Emitter(Move.prototype);
  
  /**
   * Buffer `transform`.
   *
   * @param {String} transform
   * @return {Move} for chaining
   * @api private
   */
  
  Move.prototype.transform = function(transform){
    this._transforms.push(transform);
    return this;
  };
  
  /**
   * Skew `x` and `y`.
   *
   * @param {Number} x
   * @param {Number} y
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.skew = function(x, y){
    return this.transform('skew('
      + x + 'deg, '
      + (y || 0)
      + 'deg)');
  };
  
  /**
   * Skew x by `n`.
   *
   * @param {Number} n
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.skewX = function(n){
    return this.transform('skewX(' + n + 'deg)');
  };
  
  /**
   * Skew y by `n`.
   *
   * @param {Number} n
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.skewY = function(n){
    return this.transform('skewY(' + n + 'deg)');
  };
  
  /**
   * Translate `x` and `y` axis.
   *
   * @param {Number} x
   * @param {Number} y
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.translate =
  Move.prototype.to = function(x, y){
    return this.transform(translate.join(''
      + x +'px, '
      + (y || 0)
      + 'px'));
  };
  
  /**
   * Translate on the x axis to `n`.
   *
   * @param {Number} n
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.translateX =
  Move.prototype.x = function(n){
    return this.transform('translateX(' + n + 'px)');
  };
  
  /**
   * Translate on the y axis to `n`.
   *
   * @param {Number} n
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.translateY =
  Move.prototype.y = function(n){
    return this.transform('translateY(' + n + 'px)');
  };
  
  /**
   * Scale the x and y axis by `x`, or
   * individually scale `x` and `y`.
   *
   * @param {Number} x
   * @param {Number} y
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.scale = function(x, y){
    return this.transform('scale('
      + x + ', '
      + (y || x)
      + ')');
  };
  
  /**
   * Scale x axis by `n`.
   *
   * @param {Number} n
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.scaleX = function(n){
    return this.transform('scaleX(' + n + ')')
  };
  
  /**
   * Scale y axis by `n`.
   *
   * @param {Number} n
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.scaleY = function(n){
    return this.transform('scaleY(' + n + ')')
  };
  
  /**
   * Rotate `n` degrees.
   *
   * @param {Number} n
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.rotate = function(n){
    return this.transform('rotate(' + n + 'deg)');
  };
  
  /**
   * Set transition easing function to to `fn` string.
   *
   * When:
   *
   *   - null "ease" is used
   *   - "in" "ease-in" is used
   *   - "out" "ease-out" is used
   *   - "in-out" "ease-in-out" is used
   *
   * @param {String} fn
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.ease = function(fn){
    fn = ease[fn] || fn || 'ease';
    return this.setVendorProperty('transition-timing-function', fn);
  };
  
  /**
   * Set animation properties
   *
   * @param {String} name
   * @param {Object} props
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.animate = function(name, props){
    for (var i in props){
      if (props.hasOwnProperty(i)){
        this.setVendorProperty('animation-' + i, props[i])
      }
    }
    return this.setVendorProperty('animation-name', name);
  }
  
  /**
   * Set duration to `n`.
   *
   * @param {Number|String} n
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.duration = function(n){
    n = this._duration = 'string' == typeof n
      ? parseFloat(n) * 1000
      : n;
    return this.setVendorProperty('transition-duration', n + 'ms');
  };
  
  /**
   * Delay the animation by `n`.
   *
   * @param {Number|String} n
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.delay = function(n){
    n = 'string' == typeof n
      ? parseFloat(n) * 1000
      : n;
    return this.setVendorProperty('transition-delay', n + 'ms');
  };
  
  /**
   * Set `prop` to `val`, deferred until `.end()` is invoked.
   *
   * @param {String} prop
   * @param {String} val
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.setProperty = function(prop, val){
    this._props[prop] = val;
    return this;
  };
  
  /**
   * Set a vendor prefixed `prop` with the given `val`.
   *
   * @param {String} prop
   * @param {String} val
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.setVendorProperty = function(prop, val){
    this.setProperty('-webkit-' + prop, val);
    this.setProperty('-moz-' + prop, val);
    this.setProperty('-ms-' + prop, val);
    this.setProperty('-o-' + prop, val);
    return this;
  };
  
  /**
   * Set `prop` to `value`, deferred until `.end()` is invoked
   * and adds the property to the list of transition props.
   *
   * @param {String} prop
   * @param {String} val
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.set = function(prop, val){
    this.transition(prop);
    this._props[prop] = val;
    return this;
  };
  
  /**
   * Increment `prop` by `val`, deferred until `.end()` is invoked
   * and adds the property to the list of transition props.
   *
   * @param {String} prop
   * @param {Number} val
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.add = function(prop, val){
    if (!style) return;
    var self = this;
    return this.on('start', function(){
      var curr = parseInt(self.current(prop), 10);
      self.set(prop, curr + val + 'px');
    });
  };
  
  /**
   * Decrement `prop` by `val`, deferred until `.end()` is invoked
   * and adds the property to the list of transition props.
   *
   * @param {String} prop
   * @param {Number} val
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.sub = function(prop, val){
    if (!style) return;
    var self = this;
    return this.on('start', function(){
      var curr = parseInt(self.current(prop), 10);
      self.set(prop, curr - val + 'px');
    });
  };
  
  /**
   * Get computed or "current" value of `prop`.
   *
   * @param {String} prop
   * @return {String}
   * @api public
   */
  
  Move.prototype.current = function(prop){
    return style(this.el).getPropertyValue(prop);
  };
  
  /**
   * Add `prop` to the list of internal transition properties.
   *
   * @param {String} prop
   * @return {Move} for chaining
   * @api private
   */
  
  Move.prototype.transition = function(prop){
    if (!this._transitionProps.indexOf(prop)) return this;
    this._transitionProps.push(prop);
    return this;
  };
  
  /**
   * Commit style properties, aka apply them to `el.style`.
   *
   * @return {Move} for chaining
   * @see Move#end()
   * @api private
   */
  
  Move.prototype.applyProperties = function(){
    css(this.el, this._props);
    return this;
  };
  
  /**
   * Re-select element via `selector`, replacing
   * the current element.
   *
   * @param {String} selector
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.move =
  Move.prototype.select = function(selector){
    this.el = Move.select(selector);
    return this;
  };
  
  /**
   * Defer the given `fn` until the animation
   * is complete. `fn` may be one of the following:
   *
   *   - a function to invoke
   *   - an instanceof `Move` to call `.end()`
   *   - nothing, to return a clone of this `Move` instance for chaining
   *
   * @param {Function|Move} fn
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.then = function(fn){
    // invoke .end()
    if (fn instanceof Move) {
      this.on('end', function(){
        fn.end();
      });
    // callback
    } else if ('function' == typeof fn) {
      this.on('end', fn);
    // chain
    } else {
      var clone = new Move(this.el);
      clone._transforms = this._transforms.slice(0);
      this.then(clone);
      clone.parent = this;
      return clone;
    }
  
    return this;
  };
  
  /**
   * Pop the move context.
   *
   * @return {Move} parent Move
   * @api public
   */
  
  Move.prototype.pop = function(){
    return this.parent;
  };
  
  /**
   * Reset duration.
   *
   * @return {Move}
   * @api public
   */
  
  Move.prototype.reset = function(){
    this.el.style.webkitTransitionDuration =
    this.el.style.mozTransitionDuration =
    this.el.style.msTransitionDuration =
    this.el.style.oTransitionDuration = 0;
    return this;
  };
  
  /**
   * Start animation, optionally calling `fn` when complete.
   *
   * @param {Function} fn
   * @return {Move} for chaining
   * @api public
   */
  
  Move.prototype.end = function(fn){
    var self = this;
  
    // emit "start" event
    this.emit('start');
  
    // transforms
    if (this._transforms.length) {
      this.setVendorProperty('transform', this._transforms.join(' '));
    }
  
    // transition properties
    this.setVendorProperty('transition-properties', this._transitionProps.join(', '));
    this.applyProperties();
  
    // callback given
    if (fn) this.then(fn);
  
    // emit "end" when complete
    after.once(this.el, function(){
      self.reset();
      self.emit('end');
    });
  
    return this;
  };
  
  });
  
  
  
  
  
  
  
  
  
  
  require.alias("visionmedia-move.js/index.js", "move-site/deps/move/index.js");
  require.alias("visionmedia-move.js/index.js", "move/index.js");
  require.alias("component-has-translate3d/index.js", "visionmedia-move.js/deps/has-translate3d/index.js");
  require.alias("component-transform-property/index.js", "component-has-translate3d/deps/transform-property/index.js");
  
  require.alias("yields-after-transition/index.js", "visionmedia-move.js/deps/after-transition/index.js");
  require.alias("yields-after-transition/index.js", "visionmedia-move.js/deps/after-transition/index.js");
  require.alias("yields-has-transitions/index.js", "yields-after-transition/deps/has-transitions/index.js");
  require.alias("yields-has-transitions/index.js", "yields-after-transition/deps/has-transitions/index.js");
  require.alias("yields-has-transitions/index.js", "yields-has-transitions/index.js");
  require.alias("ecarter-css-emitter/index.js", "yields-after-transition/deps/css-emitter/index.js");
  require.alias("component-emitter/index.js", "ecarter-css-emitter/deps/emitter/index.js");
  require.alias("component-indexof/index.js", "component-emitter/deps/indexof/index.js");
  
  require.alias("component-event/index.js", "ecarter-css-emitter/deps/event/index.js");
  
  require.alias("component-once/index.js", "yields-after-transition/deps/once/index.js");
  
  require.alias("yields-after-transition/index.js", "yields-after-transition/index.js");
  require.alias("ianstormtaylor-css/index.js", "visionmedia-move.js/deps/css/index.js");
  require.alias("component-type/index.js", "ianstormtaylor-css/deps/type/index.js");
  
  require.alias("ianstormtaylor-to-camel-case/index.js", "ianstormtaylor-css/deps/to-camel-case/index.js");
  require.alias("ianstormtaylor-to-space-case/index.js", "ianstormtaylor-to-camel-case/deps/to-space-case/index.js");
  require.alias("ianstormtaylor-to-no-case/index.js", "ianstormtaylor-to-space-case/deps/to-no-case/index.js");
  
  require.alias("jkroso-computed-style/index.js", "ianstormtaylor-css/deps/computed-style/index.js");
  
  require.alias("component-emitter/index.js", "visionmedia-move.js/deps/emitter/index.js");
  require.alias("component-indexof/index.js", "component-emitter/deps/indexof/index.js");
  
  require.alias("yields-css-ease/index.js", "visionmedia-move.js/deps/css-ease/index.js");
  require.alias("yields-css-ease/index.js", "visionmedia-move.js/deps/css-ease/index.js");
  require.alias("yields-css-ease/index.js", "yields-css-ease/index.js");
  require.alias("component-query/index.js", "visionmedia-move.js/deps/query/index.js");
  
  